package com.kim.smartring.db.dao;

import java.util.List;

import android.content.Context;

import com.kim.smartring.db.sqlite.DbModel;
import com.kim.smartring.db.uitls.FinalDb;

@SuppressWarnings("hiding")
public class BaseDao<T, PK> {

	protected FinalDb finalDb;
	protected Context context;

	public BaseDao(Context context) {
		this.context = context;
		finalDb = FinalDb.create(context);
	}

	/**
	 * 保存数据库，速度要比save快
	 * 
	 * @param entity
	 */
	public void save(T entity) {
		finalDb.save(entity);
	}

	/**
	 * 保存数据到数据库<br />
	 * <b>注意：</b><br />
	 * 保存成功后，entity的主键将被赋值（或更新）为数据库的主键， 只针对自增长的id有效
	 * 
	 * @param entity
	 *            要保存的数据
	 * @return ture： 保存成功 false:保存失败
	 */
	public boolean saveBindId(T entity) {
		return finalDb.saveBindId(entity);
	}

	/**
	 * 更新数据 （主键ID必须不能为空）
	 * 
	 * @param entity
	 */
	public void update(T entity) {
		finalDb.update(entity);
	}

	/**
	 * 根据条件更新数据
	 * 
	 * @param entity
	 * @param strWhere
	 *            条件为空的时候，将会更新所有的数据
	 */
	public void update(T entity, String strWhere) {
		finalDb.update(entity, strWhere);
	}

	/**
	 * 删除数据
	 * 
	 * @param entity
	 *            entity的主键不能为空
	 */
	public void delete(T entity) {
		finalDb.delete(entity);
	}

	/**
	 * 根据主键删除数据
	 * 
	 * @param clazz
	 *            要删除的实体类
	 * @param id
	 *            主键值
	 */
	public void deleteById(Class<?> clazz, PK id) {
		finalDb.deleteById(clazz, id);
	}

	/**
	 * 根据条件删除数据
	 * 
	 * @param clazz
	 * @param strWhere
	 *            条件为空的时候 将会删除所有的数据
	 */
	public void deleteByWhere(Class<?> clazz, String strWhere) {
		finalDb.deleteByWhere(clazz, strWhere);
	}

	/**
	 * 删除表的所有数据
	 * 
	 * @param clazz
	 */
	public void deleteAll(Class<?> clazz) {
		finalDb.deleteAll(clazz);
	}

	/**
	 * 删除指定的表
	 * 
	 * @param clazz
	 */
	public void dropTable(Class<?> clazz) {
		finalDb.dropTable(clazz);
	}

	/**
	 * 删除所有数据表
	 */
	public void dropDb() {
		finalDb.dropDb();
	}

	/**
	 * 根据主键查找数据（默认不查询多对一或者一对多的关联数据）
	 * 
	 * @param id
	 * @param clazz
	 */
	public <T> T findById(PK id, Class<T> clazz) {
		return finalDb.findById(id, clazz);
	}

	/**
	 * 根据主键查找，同时查找“多对一”的数据（如果有多个“多对一”属性，则查找所有的“多对一”属性）
	 * 
	 * @param id
	 * @param clazz
	 */
	public <T> T findWithManyToOneById(PK id, Class<T> clazz) {
		return finalDb.findWithManyToOneById(id, clazz);
	}

	/**
	 * 根据条件查找，同时查找“多对一”的数据（只查找findClass中的类的数据）
	 * 
	 * @param id
	 * @param clazz
	 * @param findClass
	 *            要查找的类
	 */
	public <T> T findWithManyToOneById(PK id, Class<T> clazz,
			Class<?>... findClass) {
		return finalDb.findWithManyToOneById(id, clazz, findClass);
	}

	/**
	 * 将entity中的“多对一”的数据填充满 如果是懒加载填充，则dbModel参数可为null
	 * 
	 * @param clazz
	 * @param entity
	 * @param <T>
	 * @return
	 */
	public <T> T loadManyToOne(DbModel dbModel, T entity, Class<T> clazz,
			Class<?>... findClass) {
		return finalDb.loadManyToOne(dbModel, entity, clazz, findClass);
	}

	/**
	 * 根据主键查找，同时查找“一对多”的数据（如果有多个“一对多”属性，则查找所有的一对多”属性）
	 * 
	 * @param id
	 * @param clazz
	 */
	public <T> T findWithOneToManyById(PK id, Class<T> clazz) {
		return finalDb.findWithOneToManyById(id, clazz);
	}

	/**
	 * 根据主键查找，同时查找“一对多”的数据（只查找findClass中的“一对多”）
	 * 
	 * @param id
	 * @param clazz
	 * @param findClass
	 */
	public <T> T findWithOneToManyById(PK id, Class<T> clazz,
			Class<?>... findClass) {
		return finalDb.findWithOneToManyById(id, clazz, findClass);
	}

	/**
	 * 将entity中的“一对多”的数据填充满
	 * 
	 * @param entity
	 * @param clazz
	 * @param <T>
	 * @return
	 */
	public <T> T loadOneToMany(T entity, Class<T> clazz, Class<?>... findClass) {
		return finalDb.loadOneToMany(entity, clazz, findClass);
	}

	/**
	 * 查找所有的数据
	 * 
	 * @param clazz
	 */
	public <T> List<T> findAll(Class<T> clazz) {
		return finalDb.findAll(clazz);
	}

	/**
	 * 查找所有数据
	 * 
	 * @param clazz
	 * @param orderBy
	 *            排序的字段
	 */
	public <T> List<T> findAll(Class<T> clazz, String orderBy) {
		return finalDb.findAll(clazz, orderBy);
	}

	/**
	 * 根据条件查找所有数据
	 * 
	 * @param clazz
	 * @param strWhere
	 *            条件为空的时候查找所有数据
	 */
	public <T> List<T> findAllByWhere(Class<T> clazz, String strWhere) {
		return finalDb.findAllByWhere(clazz, strWhere);
	}

	/**
	 * 根据条件查找所有数据
	 * 
	 * @param clazz
	 * @param strWhere
	 *            条件为空的时候查找所有数据
	 * @param orderBy
	 *            排序字段
	 */
	public <T> List<T> findAllByWhere(Class<T> clazz, String strWhere,
			String orderBy) {
		return finalDb.findAllByWhere(clazz, strWhere, orderBy);
	}

	/**
	 * 根据条件查找所有数据
	 * 
	 * @param clazz
	 * @param strSQL
	 */
	public <T> List<T> findAllBySql(Class<T> clazz, String strSQL) {
		return finalDb.findAllBySql(clazz, strSQL);
	}

	/**
	 * 根据sql语句查找数据，这个一般用于数据统计
	 * 
	 * @param strSQL
	 */
	public DbModel findDbModelBySQL(String strSQL) {
		return finalDb.findDbModelBySQL(strSQL);
	}

	public List<DbModel> findDbModelListBySQL(String strSQL) {
		return finalDb.findDbModelListBySQL(strSQL);
	}
}
